ngTemplateOutlet என்றால் என்ன?
<ng-template> மீண்டும் பயன்படுத்தக்கூடிய டெம்ப்ளேட் தொகுதியை வரையறுக்கிறது (ஒரு "செய்முறை").
[ngTemplateOutlet] உடன் அதை மறுவழங்கவும்.
[ngTemplateOutletContext] மூலம் மதிப்புகளை அனுப்பவும் மற்றும் let- மாறிகள் மூலம் படிக்கவும்.
டெம்ப்ளேட் அடிப்படைகள்
<ng-template> என்பது ஒரு கோப்பு வரைவு போன்றது - இது ஒரு திட்டமாகும் ஆனால் பயன்படுத்தப்படும் வரை காட்சியில் இல்லை.
[ngTemplateOutlet] அந்த திட்டத்தை உண்மையான காட்சியாக மாற்றுகிறது.
ngTemplateOutlet எப்போது பயன்படுத்த வேண்டும்
- வெவ்வேறு தரவு அல்லது மறுவழங்கல் மாறுபாடுகளுடன் UI முறைகளை மீண்டும் பயன்படுத்த
- சிக்கலான, மீண்டும் பயன்படுத்தக்கூடிய தர்க்கத்திற்கு கூறுகளைப் பயன்படுத்தவும்
- இலகுவான, காட்சி-மட்டுமே மறுபயன்பாட்டிற்கு டெம்ப்ளேட்டுகளைப் பயன்படுத்தவும்
முக்கிய உதவிக்குறிப்பு
<ng-container> ஒரு தர்க்கரீதியான மூடியாகப் பயன்படுத்தவும், இது கூடுதல் DOM உறுப்புகளைச் சேர்க்காது.
தொடர்புடையது: உள்ளடக்கத் திட்டத்திற்கான கூறுகளை <ng-content> உடன் பார்க்கவும்.
ng-template vs Component - எது எப்போது?
Use ng-template When:
- காட்சி மட்டத்தில் மீண்டும் பயன்படுத்த
- எளிய மறுவழங்கல் மாறுபாடுகள்
- இலகுவான மறுபயன்பாடு
- தனி தர்க்கம் தேவையில்லை
- வெவ்வேறு தரவு உள்ளீடுகள்
Use Component When:
- மறைக்கப்பட்ட/சுயாதீனமான தர்க்கம்
- தனி நிலை மேலாண்மை
- சிக்கலான மறுபயன்பாடு
- சுய வடிவமைப்பு மற்றும் பாணிகள்
- உள்ளீடுகள்/வெளியீடுகள் தேவை
Info Template
நீல நிற தகவல் செய்திகள்
<ng-template #infoTpl>
<p style="color:royalblue">{{ text }}</p>
</ng-template>
Warning Template
ஆரஞ்சு எச்சரிக்கை செய்திகள்
<ng-template #warnTpl>
<p style="color:darkorange">{{ text }}</p>
</ng-template>
Success Template
பச்சை வெற்றி செய்திகள்
<ng-template #successTpl>
<p style="color:seagreen">{{ text }}</p>
</ng-template>
Complete Example
Angular ngTemplateOutlet Example
import { bootstrapApplication } from '@angular/platform-browser';
import { Component } from '@angular/core';
import { CommonModule } from '@angular/common';
@Component({
selector: 'app-root',
standalone: true,
imports: [CommonModule],
template: `
<h3>Templates with ngTemplateOutlet</h3>
<label>
Type:
<select (change)="type = $any($event.target).value">
<option value="info">info</option>
<option value="warning">warning</option>
<option value="success">success</option>
</select>
</label>
<label>
Message: <input (input)="msg = $any($event.target).value" [value]="msg" />
</label>
<ng-container
[ngTemplateOutlet]="type === 'info' ? infoTpl :
(type === 'warning' ? warnTpl : successTpl)"
[ngTemplateOutletContext]="{ $implicit: msg }">
</ng-container>
<ng-template #infoTpl let-text>
<p style="color:royalblue">Info: {{ text }}</p>
</ng-template>
<ng-template #warnTpl let-text>
<p style="color:darkorange">Warning: {{ text }}</p>
</ng-template>
<ng-template #successTpl let-text>
<p style="color:seagreen">Success: {{ text }}</p>
</ng-template>
`
})
export class App {
type: 'info' | 'warning' | 'success' = 'info';
msg = 'Hello';
}
bootstrapApplication(App);
Example Explained
<ng-template>: மீண்டும் பயன்படுத்தக்கூடிய டெம்ப்ளேட் தொகுதியை வரையறுக்கிறது (குறிப்பிடப்படும் வரை மறுவழங்கப்படாது).
[ngTemplateOutlet]: எந்த டெம்ப்ளேட்டை மறுவழங்குவது என்பதைத் தேர்ந்தெடுக்கிறது (இங்கே வகையின் அடிப்படையில் மூன்று கூறு வெளிப்பாடு மூலம்).
[ngTemplateOutletContext]: டெம்ப்ளேட்டுக்குள் மதிப்புகளை அனுப்புகிறது. $implicit விசை பொருந்தக்கூடிய let- மாறியால் படிக்கப்படுகிறது.
let-text: கண்ணோட்டத்திலிருந்து $implicit மதிப்பைப் படிக்கும் டெம்ப்ளேட்டுக்குள் உள்ளூர் மாறியை அறிவிக்கிறது.
<ng-container>: கூடுதல் DOM உறுப்புகளை உருவாக்காத தர்க்கரீதியான மூடி.
டெம்ப்ளேட் கண்ணோட்டம் மற்றும் மாறிகள்
Context Passing
[ngTemplateOutletContext]="{
$implicit: 'Hello',
count: 42,
active: true
}"
$implicit: let- மாறி இல்லாமல் அணுகக்கூடிய இயல்புநிலை மதிப்பு
Variable Reading
<ng-template #myTemplate
let-data
let-cnt="count"
let-isActive="active">
{{ data }}, {{ cnt }}, {{ isActive }}
</ng-template>
let-data: $implicit ஐப் பெறுகிறது
let-cnt: "count" பண்பைப் பெறுகிறது
டெம்ப்ளேட் கண்ணோட்ட பாய்வு:
Template Definition → ngTemplateOutlet → Context Passing → Variable Reading → Rendering
↓ ↓ ↓ ↓ ↓
<ng-template> [ngTemplateOutlet] Context Object let-vars Final View
நடைமுறை பயன்பாட்டு நிகழ்வுகள்
Dynamic Card Layouts
ஒரே டெம்ப்ளேட்டுடன் வெவ்வேறு தரவு வடிவங்களுக்கான அட்டைகள்
<ng-container *ngFor="let item of items"
[ngTemplateOutlet]="cardTemplate"
[ngTemplateOutletContext]="{$implicit: item}">
</ng-container>
Conditional UI Rendering
நிலை அடிப்படையில் வெவ்வேறு UI பகுதிகளை மறுவழங்குதல்
<ng-container [ngTemplateOutlet]="
user.isAdmin ? adminTpl : userTpl">
</ng-container>
Reusable Table Rows
வெவ்வேறு அட்டவணைகளுக்கு ஒரே வரிசை வடிவமைப்பு
<tr *ngFor="let row of data"
[ngTemplateOutlet]="rowTemplate"
[ngTemplateOutletContext]="{row: row}">
</tr>
Exercise
ngTemplateOutlet என்ன செய்கிறது?
ngTemplateOutlet என்ன செய்கிறது?
ngTemplateOutlet சிறந்த நடைமுறைகள்
Use ng-container as Wrapper
கூடுதல் DOM உறுப்புகளைத் தவிர்க்க ng-container உடன் ngTemplateOutlet ஐ இணைக்கவும்
Clear Context Structure
$implicit மற்றும் தெளிவான பண்புப் பெயர்களைக் கொண்ட நன்கு கட்டமைக்கப்பட்ட கண்ணோட்டத்தைப் பயன்படுத்தவும்
Avoid Complex Logic in Outlet
ngTemplateOutlet வெளிப்பாட்டில் மிகவும் சிக்கலான தர்க்கத்தை வைக்காதீர்கள் - கூறு தர்க்கத்தைப் பயன்படுத்தவும்
Common Mistakes
- மறந்து விடுதல் <ng-container>: ngTemplateOutlet ஐ நேரடியாக div உடன் இணைக்காமல்
- தவறான கண்ணோட்ட மேப்பிங்: let- மாறிகள் கண்ணோட்ட பண்புகளுடன் பொருந்தவில்லை
- தேவையில்லாதபோது பயன்படுத்துதல்: எளிய *ngIf அல்லது *ngFor போதுமானதாக இருக்கும்போது ngTemplateOutlet பயன்படுத்துதல்